home *** CD-ROM | disk | FTP | other *** search
/ Photo CD Demo 1 / Demo.bin / hdf / mac / h10srcst.hqx / Source / HyperHell Source / App NCSA TektoPICT / rgmac.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-12-28  |  7.7 KB  |  506 lines
  1. #ifdef lint
  2. static char *SCCSid = "%W%    (NCSA)    %G%";
  3. #endif
  4.  
  5. /*
  6.  
  7. rgmac.c by Gaige B. Paulsen
  8.   spawned from rgp.c by Aaron Contorer for NCSA
  9. Copyright 1987, board of trustees, University of Illinois
  10.  
  11. Routines for Macintosh Window output.  
  12.  
  13. */
  14.  
  15.  
  16. /* 
  17.  *    Include files 
  18.  */
  19.  
  20. #include <stdio.h>
  21.  
  22. #include <Controls.h>
  23. #include <Events.h>
  24. #include <OSutils.h>
  25. #include <Packages.h>
  26. #include <Quickdraw.h>
  27. #include <Windows.h>
  28.  
  29. #ifdef MPW
  30. #include "mpw.h"
  31. #endif MPW
  32.  
  33. #define TRUE 1
  34. #define FALSE 0
  35. #define MAXWIND 20
  36. #define WINXMAX 4095
  37. #define WINYMAX 3139
  38. #define INXMAX 4096
  39. #define INYMAX 4096
  40.  
  41. #define SPLASH_SQUARED    4
  42.  
  43. char *malloc();
  44.  
  45. /*
  46.  * display structure....
  47.  */
  48.  
  49. struct RGMwindows {
  50. GrafPtr
  51.     wind;
  52. int
  53.     xorigin,
  54.     yorigin,
  55.     xscale,
  56.     yscale,
  57.     vg,
  58.     vs,
  59.     inuse,
  60.     ingin;
  61. unsigned char
  62.     *name;
  63. int
  64.     width,
  65.     height;
  66. ControlHandle
  67.     zoom,
  68.     vert,
  69.     horiz;
  70.     } RGMwind[ MAXWIND ];
  71.  
  72. long RGMlastclick;
  73.  
  74. int RGMcolor[]=
  75.     { 30,            /* black */
  76.       33,            /* white */
  77.       205,            /* red */
  78.       341,            /* green */
  79.       409,            /* blue */
  80.       273,            /* cyan */
  81.       137,            /* magenta */
  82.       69            /* yellow */
  83.       };
  84.  
  85.  
  86. char *macname = "Macintosh Windows";
  87.  
  88.  
  89. RGGIN(w)
  90. {
  91.     if (RGsetwind(w)) return(-1);
  92.  
  93.     setgraphcurs();
  94.     RGMwind[w].ingin=1;
  95. }
  96.  
  97. RGMoutfunc(f)
  98. int (*f)();
  99. {}
  100.  
  101.  
  102. RGMpencolor(w, color)
  103. {
  104.     if (RGsetwind(w) ) return(-1);
  105.  
  106.     ForeColor((long) RGMcolor[color] );
  107. }
  108.  
  109. RGMclrscr(w)
  110. {
  111.     if (RGsetwind(w) ) return(-1);
  112.  
  113.     ForeColor((long) RGMcolor[0] );
  114.     EraseRect( &RGMwind[w].wind->portRect);
  115. }
  116.  
  117. RGMclose(w)
  118. {
  119.     if (RGsetwind(w) ) return(-1);
  120.  
  121.     DisposeWindow(RGMwind[w].wind);
  122.     RGMwind[w].inuse  = FALSE;
  123.  
  124. }
  125.  
  126. RGMpoint(w,x,y)
  127. {
  128.     if (RGsetwind(w) ) return(-1);
  129.  
  130.     MoveTo(x,y);
  131.     LineTo(x,y);
  132. } 
  133.  
  134. RGMdrawline(w,x0,y0,x1,y1)
  135. int w,x0,y0,x1,y1;
  136. {
  137.     if (RGsetwind(w) ) return(-1);
  138.  
  139.     x0 = (int) ((long) x0 * RGMwind[w].width / INXMAX);
  140.     y0 = RGMwind[w].height - (int) ((long) y0 * RGMwind[w].height / INYMAX);
  141.     x1 = (int) ((long) x1 * RGMwind[w].width/INXMAX);
  142.     y1 = RGMwind[w].height - (int) ((long) y1 * RGMwind[w].height / INYMAX);
  143.  
  144.     MoveTo(x0,y0);
  145.     LineTo(x1,y1);
  146. }
  147.  
  148. RGMpagedone(w)
  149. {
  150. }
  151.  
  152. RGMdataline(w,data,count)
  153. {}
  154.  
  155.  
  156. RGMcharmode(w,rotation,size)
  157. {}
  158.  
  159. RGMshowcur()
  160. {}
  161.  
  162. RGMlockcur()
  163. {}
  164.  
  165. RGMhidecur()
  166. {}
  167.  
  168. RGMbell(w)
  169. {}
  170.  
  171. RGMuncover(w)
  172. {}
  173.  
  174. char *RGMdevname() {
  175.     return(macname);
  176. }
  177.  
  178. RGMinit()
  179. {
  180.     int i;
  181.     for(i=0; i<20; i++) RGMwind[i].inuse=0;
  182. }
  183.  
  184. RGMinfo(w,v,a,b,c,d)
  185. int w,a,b,c,d,v;
  186. {
  187.  
  188.     RGMwind[w].vg=v;
  189. }
  190.  
  191. RGMgmode()
  192. {}
  193.  
  194. RGMtmode()
  195. {}
  196.  
  197. RGMnewwin()
  198. {
  199.     int i=0;
  200.  
  201.     while ( (i< MAXWIND) && (RGMwind[i].inuse) ) i++;
  202.  
  203.     if (i>= MAXWIND) return(-1);
  204.  
  205.     RGMwind[i].wind = GetNewWindow(256,(Ptr) 0L,(Ptr) -1L);
  206.  
  207.     if (RGMwind[i].wind==0L) {
  208.         return(-1);
  209.         }
  210.  
  211.     RGMwind[i].xorigin= 0;
  212.     RGMwind[i].yorigin= 0;
  213.     RGMwind[i].xscale = WINXMAX;
  214.     RGMwind[i].yscale = WINYMAX;
  215.     RGMwind[i].width  = 400;
  216.     RGMwind[i].height = 300;
  217.     RGMwind[i].inuse  = TRUE;
  218.     RGMwind[i].ingin  = 0;
  219.  
  220.     ValidRect( &RGMwind[i].wind->portRect);
  221.  
  222.     return(i);
  223. }
  224.  
  225.  
  226. RGattach(vg,virt,name)
  227. int vg,virt;
  228. char *name;
  229. {
  230.     int i,dnum;
  231.     long time;
  232.     char ts[50];
  233.  
  234.     if ( (dnum=RGfindbyVG( vg) ) <0) return(-1);
  235.  
  236.     RGMwind[dnum].vs=virt;
  237.     RGMwind[dnum].name=(char *)malloc(256);
  238.  
  239.     if (RGMwind[dnum].name==0L) return(-2);
  240.  
  241.     RGMwind[dnum].name[0]=165;
  242.     strncpy( &RGMwind[dnum].name[1], name,255);
  243.  
  244.     GetDateTime(&time);
  245.     IUTimeString(time,FALSE, ts);                /* Put time in the temp string */
  246.     
  247.     strncat( RGMwind[dnum].name, "  ",255);            /* Space, please */
  248.     strncat( RGMwind[dnum].name, ts,255);            /* Place the time string at the end */
  249.  
  250.     SetWTitle(RGMwind[dnum].wind,RGMwind[dnum].name);
  251.     return(0);
  252. }
  253.  
  254. RGdetach(dnum)
  255. int dnum;
  256. {
  257.     int i;
  258.     if (dnum<0 || dnum>=MAXWIND) return(-1);
  259.  
  260.     strncpy( RGMwind[dnum].name, &RGMwind[dnum].name[1], 255);
  261.  
  262.     SetWTitle(RGMwind[dnum].wind,RGMwind[dnum].name);
  263.  
  264.     RGMwind[dnum].vs=-1;
  265. }
  266.  
  267. RGsetwind(dnum)
  268. int dnum;
  269. {
  270.  
  271.     if (dnum<0 || dnum>=MAXWIND) return(-1);
  272.  
  273.     if (!RGMwind[dnum].inuse) return(-1);
  274.  
  275.     SetPort( RGMwind[dnum].wind);
  276.     return(0);
  277. }
  278.  
  279. RGupdate(wind)
  280. GrafPtr wind;
  281. {
  282.     int i=0,done;
  283.  
  284.     if ( (i=RGfindbywind(wind)) <0)
  285.         return(-1);
  286.  
  287.     SetPort(wind);
  288.     BeginUpdate(wind);
  289.  
  290.     VGstopred( RGMwind[i].vg);
  291.     VGpage( RGMwind[i].vg);
  292.     done = VGpred(  RGMwind[i].vg,  RGMwind[i].vg);
  293.     EndUpdate(wind);
  294.     if (!done)
  295.         netputevent(1,128,RGMwind[i].vg);
  296.     return(done);
  297. }
  298.  
  299. RGsupdate(i)
  300. {
  301.     int rg;
  302.     rg=RGfindbyVG( i);
  303.  
  304.     if (rg<0) return(0);
  305.     SetPort( RGMwind[rg].wind);
  306.     if (!VGpred(  RGMwind[rg].vg,  RGMwind[rg].vg) ) {
  307.         netputevent( 1, 128, i);
  308.         }
  309.     else return(1);
  310.     return(0);
  311. }
  312.  
  313. RGgetVG(wind)
  314. GrafPtr wind;
  315. {
  316.     int i;
  317.  
  318.     i=RGfindbywind(wind);
  319.  
  320.     return( RGMwind[i].vg);
  321. }
  322.  
  323. RGgetdnum(wind)
  324. GrafPtr wind;
  325. {
  326.     return(RGfindbywind(wind) );
  327. }
  328.  
  329. RGfindbyVG( vg)
  330. int vg;
  331. {
  332.     int i=0;
  333.  
  334.     while ((i<MAXWIND) && ((!RGMwind[i].inuse) || (RGMwind[i].vg!=vg)))
  335.         i++;
  336.     if (i>=MAXWIND) return(-1);
  337.     return(i);
  338. }
  339.  
  340. RGgetVS( dnum)
  341. int dnum;
  342. {
  343.     return( RGMwind[dnum].vs);
  344. }
  345.  
  346.  
  347. RGfindbywind(wind)
  348. GrafPtr wind;
  349. {
  350.     int i=0;
  351.  
  352.     while ((i<MAXWIND) && ((!RGMwind[i].inuse) || (RGMwind[i].wind!=wind)))
  353.         i++;
  354.     if (i>=MAXWIND) return(-1);
  355.     return(i);
  356. }
  357.  
  358. inSplash( p1, p2)
  359. Point *p1,*p2;
  360. {
  361.     if (p1->h-p2->h>3 || p2->h-p1->h >3)
  362.         return(0);
  363.     if (p1->v-p2->v>3 || p2->v-p1->v >3)
  364.         return(0);
  365.  
  366.     return(1);
  367. }
  368.  
  369. RGmousedown( wind, wherein, pnum)
  370. GrafPtr wind;
  371. Point *wherein;
  372. {
  373.     long lx,ly;
  374.     char thispaceforent[6];
  375.     int i;
  376.     Point where;
  377.  
  378.     where = *wherein;
  379.     if ( (i=RGfindbywind(wind)) <0)
  380.         return(-1);
  381.  
  382.     if (!RGMwind[i].ingin) {
  383.         Point anchor, current,last;
  384. #ifndef MPW
  385.         long TickCount();
  386. #endif MPW
  387.         long GetDblTime(),tc;
  388.         int x0,y0,x1,y1;
  389.         Rect rect;
  390.         char dum[50];
  391.     
  392.         SetPort(wind);
  393.     
  394.         last  = where;
  395.         current = where;
  396.         anchor = where;
  397.     
  398.         PenPat(qd.gray);    
  399.         PenMode( patXor);
  400.     
  401.         SetRect( &rect, 0,0,0,0);
  402.     
  403.         while (StillDown()) {
  404.             GetMouse( ¤t);
  405.             if ( inSplash( ¤t, &anchor) ) continue;
  406.             tc=TickCount();
  407.             while(TickCount()==tc);
  408.             VidSync();
  409.             FrameRect(&rect);
  410.     
  411.             if (anchor.v < current.v) {
  412.                 rect.top=anchor.v;
  413.                 rect.bottom=current.v;
  414.                 }
  415.             else {
  416.                 rect.top=current.v;
  417.                 rect.bottom=anchor.v;
  418.                 }
  419.     
  420.             if (anchor.h < current.h) {
  421.                 rect.left=anchor.h;
  422.                 rect.right=current.h;
  423.                 }
  424.             else {
  425.                 rect.right=anchor.h;
  426.                 rect.left =current.h;
  427.                 }
  428.     
  429.             FrameRect(&rect);
  430.             last=current;
  431.             }
  432.     
  433.         FrameRect(&rect);
  434.  
  435.         PenPat(qd.black);    
  436.         PenMode( patCopy);
  437.  
  438.         if ( !inSplash( &anchor, ¤t)) {
  439.             x0 = (int) ((long) rect.left * RGMwind[i].xscale / RGMwind[i].width );
  440.             y0 = (int) RGMwind[i].yscale -
  441.                  ((long) rect.top * RGMwind[i].yscale / RGMwind[i].height);
  442.             x1 = (int) ((long) rect.right * RGMwind[i].xscale / RGMwind[i].width);
  443.             y1 = (int) RGMwind[i].yscale -
  444.                  ((long) rect.bottom * RGMwind[i].yscale / RGMwind[i].height);
  445.  
  446.             VGzoom( i,
  447.                     x0 +RGMwind[i].xorigin,
  448.                     y1 +RGMwind[i].yorigin,
  449.                     x1 +RGMwind[i].xorigin,
  450.                     y0 +RGMwind[i].yorigin);
  451.  
  452.             VGpage( RGMwind[i].vg);
  453.  
  454.             RGMwind[i].xscale= x1-x0;
  455.             RGMwind[i].yscale= y0-y1;
  456.             RGMwind[i].xorigin= x0+ RGMwind[i].xorigin;
  457.             RGMwind[i].yorigin= y1+ RGMwind[i].yorigin;
  458.  
  459.             sprintf(dum,"VGzoom [%d,%d] -[%d,%d]", x0,y1,x1,y0);
  460.             putln(dum);
  461.             while( !VGpred(  RGMwind[i].vg,  RGMwind[i].vg) )
  462.                 Stask();
  463.             RGMlastclick=0L;
  464.             }
  465.         else {
  466.             if (RGMlastclick && ((RGMlastclick +GetDblTime() ) > TickCount()) ) {
  467.                 RGMwind[i].xscale = WINXMAX;
  468.                 RGMwind[i].yscale = WINYMAX;
  469.                 RGMwind[i].xorigin= 0;
  470.                 RGMwind[i].yorigin= 0;
  471.  
  472.                 VGzoom(i,0,0,WINXMAX,WINYMAX);
  473.                 VGpage( RGMwind[i].vg);
  474.                 while( !VGpred(  RGMwind[i].vg,  RGMwind[i].vg) )
  475.                     Stask();
  476.                 RGMlastclick=0L;
  477.                 }
  478.             else RGMlastclick=TickCount();
  479.             }
  480.         return(0);
  481.     
  482.     }
  483.  
  484.  
  485.     lx= (RGMwind[i].xscale * where.h) / ((long)RGMwind[i].width);
  486.     ly= RGMwind[i].yscale - ((RGMwind[i].yscale * where.v) / ((long)RGMwind[i].height));
  487.  
  488.     VGgindata( RGMwind[i].vg, (int) lx, (int) ly, ' ', thispaceforent);
  489.  
  490.     RSsendstring( RGMwind[i].vs, thispaceforent, 5);
  491.  
  492.     RGMwind[i].ingin=0;
  493.     unsetgraphcurs();
  494.     RGMlastclick=TickCount();
  495. }
  496.  
  497. long *Ticks= (long *)0x16a;
  498.  
  499. VidSync()
  500. {
  501.     long a;
  502.  
  503.     a= *Ticks;
  504.     while (a ==*Ticks);
  505. }
  506.